Alternativas ao Enum do TypeScript: Declarações Const vs. Tipos de União

O enum do TypeScript é um recurso poderoso para definir um conjunto de constantes nomeadas. No entanto, nem sempre é a melhor escolha. Este artigo explora alternativas aos enums, especificamente declarações const e tipos de união, e fornece orientação sobre quando usar cada um para otimizar a qualidade, a manutenção e o desempenho do código. Analisaremos as nuances de cada abordagem, oferecendo exemplos práticos e abordando preocupações comuns.

Entendendo os Enums do TypeScript

Antes de mergulhar nas alternativas, vamos revisar rapidamente os enums do TypeScript. Um enum é uma maneira de definir um conjunto de constantes numéricas nomeadas. Por padrão, o primeiro membro do enum recebe o valor 0 e os membros subsequentes são incrementados em 1.

            
enum Status {
  Pending,
  InProgress,
  Completed,
  Rejected,
}

const currentStatus: Status = Status.InProgress; // currentStatus will be 1

            

              
                Copy
              
            
          

Você também pode atribuir valores explicitamente aos membros do enum:

            
enum HTTPStatus {
  OK = 200,
  BadRequest = 400,
  Unauthorized = 401,
  Forbidden = 403,
  NotFound = 404,
}

const serverResponse: HTTPStatus = HTTPStatus.OK; // serverResponse will be 200

            

              
                Copy
              
            
          

Benefícios dos Enums

• Legibilidade: Os enums melhoram a legibilidade do código, fornecendo nomes significativos para constantes numéricas.
• Segurança de Tipo: Eles impõem a segurança de tipo, restringindo os valores aos membros do enum definidos.
• Autocompletar: Os IDEs fornecem sugestões de autocompletar para membros do enum, reduzindo erros.

Desvantagens dos Enums

• Sobrecarga de Tempo de Execução: Os enums são compilados em objetos JavaScript, o que pode introduzir sobrecarga de tempo de execução, especialmente em aplicações grandes.
• Mutação: Os enums são mutáveis por padrão. Embora o TypeScript forneça const enum para impedir a mutação, ele tem limitações.
• Mapeamento Inverso: Os enums numéricos criam um mapeamento inverso (por exemplo, Status[1] retorna "InProgress"), o que geralmente é desnecessário e pode aumentar o tamanho do pacote.

Alternativa 1: Declarações Const

As declarações const fornecem uma maneira de criar estruturas de dados imutáveis e somente leitura. Elas podem ser usadas como uma alternativa aos enums em muitos casos, especialmente quando você precisa de um conjunto simples de constantes de string ou numéricas.

            
const Status = {
  Pending: 'pending',
  InProgress: 'in_progress',
  Completed: 'completed',
  Rejected: 'rejected',
} as const;

// Typescript infers the following type:
// {
//    readonly Pending: "pending";
//    readonly InProgress: "in_progress";
//    readonly Completed: "completed";
//    readonly Rejected: "rejected";
// }

type StatusType = typeof Status[keyof typeof Status]; // 'pending' | 'in_progress' | 'completed' | 'rejected'

function processStatus(status: StatusType) {
  console.log(`Processing status: ${status}`);
}

processStatus(Status.InProgress); // Valid
// processStatus('invalid'); // Error: Argument of type '"invalid"' is not assignable to parameter of type 'StatusType'.

            

              
                Copy
              
            
          

Neste exemplo, definimos um objeto JavaScript simples com valores de string. A declaração as const diz ao TypeScript para tratar este objeto como somente leitura e inferir os tipos mais específicos para suas propriedades. Em seguida, extraímos um tipo de união das chaves. Esta abordagem oferece várias vantagens:

Benefícios das Declarações Const

• Imutabilidade: As declarações const criam estruturas de dados imutáveis, evitando modificações acidentais.
• Sem Sobrecarga de Tempo de Execução: Eles são objetos JavaScript simples, portanto, não há sobrecarga de tempo de execução associada aos enums.
• Segurança de Tipo: Eles fornecem forte segurança de tipo, restringindo os valores às constantes definidas.
• Compatível com Tree-shaking: Bundlers modernos podem facilmente tree-shake valores não utilizados, reduzindo o tamanho do pacote.

Considerações para Declarações Const

• Mais verboso: Definir e tipar pode ser um pouco mais verboso do que enums, especialmente para casos simples.
• Sem Mapeamento Inverso: Eles não fornecem mapeamento inverso, mas isso geralmente é um benefício em vez de uma desvantagem.

Alternativa 2: Tipos de União

Os tipos de união permitem que você defina uma variável que pode conter um de vários tipos possíveis. Eles são uma maneira mais direta de definir os valores permitidos sem um objeto, o que é benéfico quando você não precisa da relação chave-valor de um enum ou declaração const.

            
type Status = 'pending' | 'in_progress' | 'completed' | 'rejected';

function processStatus(status: Status) {
  console.log(`Processing status: ${status}`);
}

processStatus('in_progress'); // Valid
// processStatus('invalid'); // Error: Argument of type '"invalid"' is not assignable to parameter of type 'Status'.

            

              
                Copy
              
            
          

Esta é uma maneira concisa e segura de definir um conjunto de valores permitidos.

Benefícios dos Tipos de União

• Conciso: Os tipos de união são a abordagem mais concisa, especialmente para conjuntos simples de constantes de string ou numéricas.
• Segurança de Tipo: Eles fornecem forte segurança de tipo, restringindo os valores às opções definidas.
• Sem Sobrecarga de Tempo de Execução: Os tipos de união existem apenas em tempo de compilação e não têm representação em tempo de execução.

Considerações para Tipos de União

• Sem Associação Chave-Valor: Eles não fornecem uma relação chave-valor como enums ou declarações const. Isso significa que você não pode facilmente procurar um valor pelo seu nome.
• Repetição de Literais de String: Você pode precisar repetir literais de string se usar o mesmo conjunto de valores em vários lugares. Isso pode ser atenuado com uma definição de type compartilhada.

Quando Usar Qual?

A melhor abordagem depende de suas necessidades e prioridades específicas. Aqui está um guia para ajudá-lo a escolher:

• Use Enums Quando:
  • Você precisa de um conjunto simples de constantes numéricas com incremento implícito.
  • Você precisa de mapeamento inverso (embora isso raramente seja necessário).
  • Você está trabalhando com código legado que já usa enums extensivamente e não tem necessidade urgente de alterá-lo.
• Use Declarações Const Quando:
  • Você precisa de um conjunto de constantes de string ou numéricas que devem ser imutáveis.
  • Você precisa de uma relação chave-valor e deseja evitar sobrecarga de tempo de execução.
  • Tree-shaking e tamanho do pacote são considerações importantes.
• Use Tipos de União Quando:
  • Você precisa de uma maneira simples e concisa de definir um conjunto de valores permitidos.
  • Você não precisa de uma relação chave-valor.
  • Desempenho e tamanho do pacote são críticos.

Cenário de Exemplo: Definindo Funções de Usuário

Vamos considerar um cenário em que você precisa definir funções de usuário em uma aplicação. Você pode ter funções como "Admin", "Editor" e "Visualizador".

Usando Enums:

            
enum UserRole {
  Admin,
  Editor,
  Viewer,
}

function authorize(role: UserRole) {
  // ...
}

            

              
                Copy
              
            
          

Usando Declarações Const:

            
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

function authorize(role: UserRoleType) {
  // ...
}

            

              
                Copy
              
            
          

Usando Tipos de União:

            
type UserRole = 'admin' | 'editor' | 'viewer';

function authorize(role: UserRole) {
  // ...
}

            

              
                Copy
              
            
          

Neste cenário, os tipos de união oferecem a solução mais concisa e eficiente. As declarações const são uma boa alternativa se você preferir uma relação chave-valor, talvez para procurar descrições de cada função. Os enums geralmente não são recomendados aqui, a menos que você tenha uma necessidade específica de valores numéricos ou mapeamento inverso.

Cenário de Exemplo: Definindo Códigos de Status do Endpoint da API

Vamos considerar um cenário em que você precisa definir códigos de status do endpoint da API. Você pode ter códigos como 200 (OK), 400 (Solicitação Inválida), 401 (Não Autorizado) e 500 (Erro Interno do Servidor).

Usando Enums:

            
enum StatusCode {
  OK = 200,
  BadRequest = 400,
  Unauthorized = 401,
  InternalServerError = 500
}

function processStatus(code: StatusCode) {
  // ...
}

            

              
                Copy
              
            
          

Usando Declarações Const:

            
const StatusCode = {
  OK: 200,
  BadRequest: 400,
  Unauthorized: 401,
  InternalServerError: 500
} as const;

type StatusCodeType = typeof StatusCode[keyof typeof StatusCode];

function processStatus(code: StatusCodeType) {
  // ...
}

            

              
                Copy
              
            
          

Usando Tipos de União:

            
type StatusCode = 200 | 400 | 401 | 500;

function processStatus(code: StatusCode) {
  // ...
}

            

              
                Copy
              
            
          

Novamente, os tipos de união oferecem a solução mais concisa e eficiente. As declarações const são uma alternativa forte e podem ser preferíveis, pois fornecem uma descrição mais detalhada para um determinado código de status. Os enums podem ser úteis se bibliotecas ou APIs externas esperarem códigos de status baseados em inteiros, e você quiser garantir uma integração perfeita. Os valores numéricos se alinham aos códigos HTTP padrão, simplificando potencialmente a interação com os sistemas existentes.

Considerações de Desempenho

Na maioria dos casos, a diferença de desempenho entre enums, declarações const e tipos de união é insignificante. No entanto, em aplicações críticas para o desempenho, é importante estar ciente das possíveis diferenças.

• Enums: Os enums introduzem sobrecarga de tempo de execução devido à criação de objetos JavaScript. Essa sobrecarga pode ser significativa em aplicações grandes com muitos enums.
• Declarações Const: As declarações const não têm sobrecarga de tempo de execução. Eles são objetos JavaScript simples que são tratados como somente leitura pelo TypeScript.
• Tipos de União: Os tipos de união não têm sobrecarga de tempo de execução. Eles existem apenas em tempo de compilação e são apagados durante a compilação.

Se o desempenho for uma grande preocupação, os tipos de união são geralmente a melhor escolha. As declarações const também são uma boa opção, especialmente se você precisar de uma relação chave-valor. Evite usar enums em seções de código críticas para o desempenho, a menos que você tenha uma razão específica para fazê-lo.

Implicações Globais e Melhores Práticas

Ao trabalhar em projetos com equipes internacionais ou usuários globais, é crucial considerar a localização e a internacionalização. Aqui estão algumas práticas recomendadas para usar enums e suas alternativas em um contexto global:

• Use nomes descritivos: Escolha nomes de membros do enum (ou chaves de declaração const) que sejam claros e inequívocos, mesmo para falantes não nativos de inglês. Evite gírias ou jargões.
• Considere a localização: Se você precisar exibir nomes de membros do enum para os usuários, considere usar uma biblioteca de localização para fornecer traduções para diferentes idiomas. Por exemplo, em vez de exibir diretamente Status.InProgress, você pode exibir i18n.t('status.in_progress').
• Evite suposições específicas da cultura: Esteja atento às diferenças culturais ao definir valores de enum. Por exemplo, formatos de data, símbolos de moeda e unidades de medida podem variar significativamente entre as culturas. Se você precisar representar esses valores, considere usar uma biblioteca que lide com localização e internacionalização.
• Documente seu código: Forneça documentação clara e concisa para seus enums e suas alternativas, explicando seu propósito e uso. Isso ajudará outros desenvolvedores a entender seu código, independentemente de sua experiência ou formação.

Exemplo: Localizando Funções de Usuário

Vamos revisitar o exemplo das funções de usuário e considerar como localizar os nomes das funções para diferentes idiomas.

            
// Usando Declarações Const com Localização
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

// Função de localização (usando uma biblioteca i18n hipotética)
function getLocalizedRoleName(role: UserRoleType, locale: string): string {
  switch (role) {
    case UserRole.Admin:
      return i18n.t('user_role.admin', { locale });
    case UserRole.Editor:
      return i18n.t('user_role.editor', { locale });
    case UserRole.Viewer:
      return i18n.t('user_role.viewer', { locale });
    default:
      return 'Função Desconhecida';
  }
}

// Exemplo de uso
const currentRole: UserRoleType = UserRole.Editor;
const localizedRoleName = getLocalizedRoleName(currentRole, 'fr-CA'); // Retorna "Éditeur" localizado para francês canadense.
console.log(`Função atual: ${localizedRoleName}`);

            

              
                Copy
              
            
          

Neste exemplo, usamos uma função de localização para recuperar o nome da função traduzida com base na localidade do usuário. Isso garante que os nomes das funções sejam exibidos no idioma preferido do usuário.

Conclusão

Os enums do TypeScript são um recurso útil, mas nem sempre são a melhor escolha. As declarações const e os tipos de união oferecem alternativas viáveis que podem fornecer melhor desempenho, imutabilidade e manutenção do código. Ao entender os benefícios e as desvantagens de cada abordagem, você pode tomar decisões informadas sobre qual usar em seus projetos. Considere as necessidades específicas de sua aplicação, as preferências de sua equipe e a manutenção de longo prazo de seu código. Ao ponderar cuidadosamente esses fatores, você pode escolher a melhor abordagem para definir constantes em seus projetos TypeScript, levando a bases de código mais limpas, eficientes e de fácil manutenção.